package com.lmaos.basetools.base;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import com.lmaos.allcontrol.beancontrol.field_.FieldUtils;

public class SearchMap extends SParamMap{
	/** 时间：2017年7月17日 下午11:56:31 <br>
	 *  说明：
	 */
	private static final long serialVersionUID = 1L;
	Map<String, Map<String,Object>> searchMap = null;
	Map<String, Map<String,Object>> searchMapDirectly = null;
	public SearchMap(Map<String,Object> map) {
		super(map);
		this.searchMap = createSearch(map);
		this.searchMapDirectly = createSearchDirectly(map);
	}
	public SearchMap() {
		searchMap = new ConcurrentHashMap<String, Map<String,Object>>();
		searchMapDirectly = new ConcurrentHashMap<String, Map<String,Object>>();
	}
	/** 
	 * 说明：查找全部所属	<br>
	 * 时间：2017年7月18日 下午16:28:51
	 *
	 * @param path
	 * @return
	 */
	public SParamMap searchByParentPath(String path){
		if(!path.endsWith("/")){
			path+="/";
		}
		Map<String,Object> map = searchMap.get(path);
		if(map == null){
			return new SParamMap();
		}else{
			return new SParamMap(map);
		}
	}
	
	/** 
	 * 说明：查找直属子类	<br>
	 * 时间：2017年7月18日 下午16:28:51
	 *
	 * @param path
	 * @return
	 */
	public SParamMap searchDirectlyByParentPath(String path){
		if(!path.endsWith("/")){
			path+="/";
		}
		Map<String,Object> map = searchMapDirectly.get(path);
		if(map == null){
			return new SParamMap();
		}else{
			return new SParamMap(map);
		}
	}
	
	/** 建立所有包含的子集
	 * 说明：创建所属搜索索引,key 必须为 / 分割父子关系的结构		<br>
	 * 时间：2017年7月17日 下午11:47:51
	 *
	 * @param map
	 * @return
	 */
	public static Map<String, Map<String,Object>> createSearch(Map<String,Object> map){
		Map<String, Map<String,Object>> searchMap = new ConcurrentHashMap<String, Map<String,Object>>(64);
		if(map!=null){
			for(Entry<String, Object> entry:map.entrySet())
			{
				String key = entry.getKey();
				List<String> parentPaths = getParentPaths(key);
				for (String parentPath : parentPaths) {
					Map<String,Object> childMap = searchMap.get(parentPath);
					if(childMap == null){
						childMap = new HashMap<String, Object>();
						searchMap.put(parentPath, childMap);
					}
					childMap.put(key, entry.getValue());
				}
			}
		}
		return searchMap;
	}
	
	/** 建立直属子类  <BR>
	 * 说明：创建所属搜索索引,key 必须为 / 分割父子关系的结构		<br>
	 * 时间：2017年7月18日 下午16:28:51
	 *
	 * @param map
	 * @return
	 */
	public static Map<String, Map<String,Object>> createSearchDirectly(Map<String,Object> map){
		Map<String, Map<String,Object>> searchMap = new ConcurrentHashMap<String, Map<String,Object>>(64);
		if(map!=null){
			for(Entry<String, Object> entry:map.entrySet())
			{
				String key = entry.getKey();
				String parentPath = getParentPath(key);
				if(parentPath!=null){
					Map<String,Object> childMap = searchMap.get(parentPath);
					if(childMap == null){
						childMap = new HashMap<String, Object>();
						searchMap.put(parentPath, childMap);
					}
					childMap.put(key, entry.getValue());
				}
			}
		}
		return searchMap;
	}
	
	
	/**
	 * 说明：对象通过这个字段分组成map		<br>
	 * 时间：2017年7月18日 上午12:03:47
	 *
	 * @param key_field 分组字段
	 * @param colls
	 * @param repeatRemind 发生重复异常提醒
	 * @param errend 发生重复错误则发生异常,否则只提示重复内容
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static Map<String, Object> toMap(String key_field,Collection colls,boolean repeatRemind,boolean errend){
		Map<String, Object> map = new HashMap<String, Object>();
		for (Object object : colls) {
			Object value = FieldUtils.getFieldValue(object, key_field);
			if(value != null){
				String key = String.valueOf(value);
				if(repeatRemind&&map.containsKey(key)){
					String info = "建立唯一索引key重复，记录存在重复,KEY="+key+",解决方式[请检查集合中唯一值字段是否有重复内容]";
					if(errend){
						throw new SearchKeyRepeatException("终止! "+info);
					}else{
						System.err.println("提醒！ "+info);
					}
				}
				map.put(String.valueOf(value), object);
			}
		}
		return map;
	}
	/**
	 * 说明：对象通过这个字段分组成map		<br>
	 * 时间：2017年7月18日 上午12:03:47
	 *
	 * @param key_field 分组字段
	 * @param colls
	 * @return
	 */
	@SuppressWarnings("rawtypes")
	public static Map<String, Object> toMap(String key_field,Collection colls){
		return toMap(key_field, colls, false,false);
	}
	/**
	 * 说明：获得全部父路径		<br>
	 * 时间：2017年7月17日 下午11:48:39
	 *
	 * @param key
	 * @return
	 */
	public static List<String> getParentPaths(String key){
		List<String> paths = new ArrayList<String>();
		StringBuilder path = new StringBuilder();
		int length = key.length();
		for (int i=0;i<length;i++) {
			char c = key.charAt(i);
			path.append(c);
			if(c == '/' && i!=length-1){
				paths.add(path.toString());
			}
		}
		return paths;
	}
	// 获得当前父路径
	public static String getParentPath(String key){
		if(key==null||key.equals("/")||key.isEmpty()){
			return null;
		}
		int parentSplit = key.length()-2;
		
		parentSplit = key.lastIndexOf("/",parentSplit);
		if(parentSplit == -1){
			return "/";
		}
		
		return key.substring(0,parentSplit+1);
	}
	
	public static void main(String[] args) {
		
		System.out.println(getParentPath("/67/ui/x"));
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("/a/b/1", "2345");
		map.put("/a/c/2", "444");
		map.put("/a/c/0", "444");
		map.put("/a/e/3", "555");
		SearchMap searchMap = new SearchMap(map);
		System.out.println(searchMap.searchByParentPath("/a/"));
		
		System.out.println(createSearchDirectly(map));
	}
}
class SearchKeyRepeatException extends RuntimeException{

	private static final long serialVersionUID = 1L;
	public SearchKeyRepeatException(String msg) {
		super(msg);
	}
	
}
